package config

import (
	"encoding/json"
	"net/http"
	"os"
	"time"
)

// HealthCheckConfig 健康检查配置
type HealthCheckConfig struct {
	CheckPath     string            `json:"check_path"`     // 健康检查路径
	CheckMethod   string            `json:"check_method"`   // 检查请求方法
	CheckHeaders  map[string]string `json:"check_headers"`  // 检查请求头
	CheckBody     string            `json:"check_body"`     // 检查请求体
	SuccessCodes  []int             `json:"success_codes"`  // 成功状态码列表
	Interval      int               `json:"interval"`       // 检查间隔（秒）
	Timeout       int               `json:"timeout"`        // 超时时间（秒）
	RetryInterval int               `json:"retry_interval"` // 重试间隔（秒）
}

// ServerConfig 服务器配置
type ServerConfig struct {
	URL                 string                      `json:"url"`
	IsMain              bool                        `json:"is_main"`
	MaxIdleConns        int                         `json:"max_idle_conns"`
	MaxIdleConnsPerHost int                         `json:"max_idle_conns_per_host"`
	MaxConnsPerHost     int                         `json:"max_conns_per_host"`
	MaxFailCount        int64                       `json:"max_fail_count"`         // 最大连续失败次数
	BlacklistDuration   string                      `json:"blacklist_duration"`     // 黑名单持续时间
	LoadThreshold       int64                       `json:"load_threshold"`         // 负载阈值
	HealthCheck         *HealthCheckConfig          `json:"health_check,omitempty"` // 服务器特定的健康检查配置
	CircuitBreaker      *CircuitBreakerConfig       `json:"circuit_breaker,omitempty"` // 服务器特定的熔断配置
	CustomDirector      func(*http.Request, string) `json:"-"`                      // 自定义路径处理函数
}

// RouteRule 路由规则配置
type RouteRule struct {
	Version    string         `json:"version"`     // 版本标识
	PathPrefix string         `json:"path_prefix"` // URL路径前缀
	Servers    []ServerConfig `json:"servers"`     // 服务器列表
}

// RateLimit 速率限制配置
type RateLimit struct {
	Path          string `json:"path"`          // 限流路径，支持前缀匹配
	RequestsPerSec int    `json:"requests_per_sec"` // 每秒最大请求数
	BurstSize     int    `json:"burst_size"`    // 突发请求处理量
}

// CircuitBreakerConfig 熔断器配置
type CircuitBreakerConfig struct {
	ErrorThreshold       float64       `json:"error_threshold"`        // 错误阈值，百分比
	MinimumRequests      int           `json:"minimum_requests"`       // 触发熔断的最小请求数
	BreakDuration        string        `json:"break_duration"`         // 熔断持续时间
	HalfOpenMaxRequests  int           `json:"half_open_max_requests"` // 半开状态最大请求数
	parsedBreakDuration  time.Duration `json:"-"`                      // 解析后的熔断持续时间
}

// GetBreakDuration 获取熔断持续时间
func (c *CircuitBreakerConfig) GetBreakDuration() time.Duration {
	if c.parsedBreakDuration == 0 && c.BreakDuration != "" {
		c.parsedBreakDuration, _ = time.ParseDuration(c.BreakDuration)
		if c.parsedBreakDuration == 0 {
			c.parsedBreakDuration = 60 * time.Second // 默认60秒
		}
	}
	return c.parsedBreakDuration
}

// Config 全局配置
type Config struct {
	Gateway struct {
		Port            int `json:"port"`
		ProcessSettings struct {
			WorkerCount          int    `json:"worker_count"`
			WorkerPortStart      int    `json:"worker_port_start"`
			MaxRequestsPerWorker int    `json:"max_requests_per_worker"`
			LoadBalanceStrategy  string `json:"load_balance_strategy"`
		} `json:"process_settings"`
		// 新增限流配置
		RateLimits     []RateLimit `json:"rate_limits"`
		// 全局限流配置
		GlobalRateLimit struct {
			Enabled        bool `json:"enabled"`
			RequestsPerSec int  `json:"requests_per_sec"`
			BurstSize      int  `json:"burst_size"`
		} `json:"global_rate_limit"`
	} `json:"gateway"`

	RouteRules []RouteRule `json:"route_rules"` // 路由规则列表

	ServerSettings struct {
		MaxIdleConns         int   `json:"max_idle_conns"`
		MaxIdleConnsPerHost  int   `json:"max_idle_conns_per_host"`
		MaxConnsPerHost      int   `json:"max_conns_per_host"`
		LoadBalanceThreshold int64 `json:"load_balance_threshold"` // 负载均衡阈值
		RequestTimeout       int   `json:"request_timeout"`        // 请求超时时间（秒）
		CircuitBreaker       CircuitBreakerConfig `json:"circuit_breaker"` // 熔断器配置
	} `json:"server_settings"`

	HealthCheck HealthCheckConfig `json:"health_check"` // 全局健康检查配置
	
	// 日志配置
	Logging struct {
		Level      string `json:"level"`       // 日志级别：debug, info, warn, error
		Format     string `json:"format"`      // 日志格式：text, json
		TimeFormat string `json:"time_format"` // 时间格式
		Output     string `json:"output"`      // 输出位置：stdout, file
		FilePath   string `json:"file_path"`   // 日志文件路径
	} `json:"logging"`
}

// LoadConfig 从文件加载配置
func LoadConfig(filepath string) (*Config, error) {
	if filepath == "" {
		return DefaultConfig(), nil
	}

	file, err := os.Open(filepath)
	if err != nil {
		return DefaultConfig(), nil
	}
	defer file.Close()

	config := &Config{}
	if err := json.NewDecoder(file).Decode(config); err != nil {
		return nil, err
	}

	// 设置默认值
	if config.HealthCheck.CheckPath == "" {
		config.HealthCheck.CheckPath = "/health"
	}
	if config.HealthCheck.CheckMethod == "" {
		config.HealthCheck.CheckMethod = "GET"
	}
	if len(config.HealthCheck.SuccessCodes) == 0 {
		config.HealthCheck.SuccessCodes = []int{200}
	}
	if config.HealthCheck.RetryInterval == 0 {
		config.HealthCheck.RetryInterval = 5 // 默认5秒
	}
	if config.ServerSettings.LoadBalanceThreshold == 0 {
		config.ServerSettings.LoadBalanceThreshold = 100 // 默认负载阈值
	}

	return config, nil
}

// DefaultConfig 返回默认配置
func DefaultConfig() *Config {
	config := &Config{}
	config.Gateway.Port = 1240
	config.Gateway.ProcessSettings.WorkerCount = 4
	config.Gateway.ProcessSettings.WorkerPortStart = 1241
	config.Gateway.ProcessSettings.MaxRequestsPerWorker = 1000
	config.Gateway.ProcessSettings.LoadBalanceStrategy = "least_conn"
	
	// 默认全局限流配置
	config.Gateway.GlobalRateLimit.Enabled = true
	config.Gateway.GlobalRateLimit.RequestsPerSec = 1000
	config.Gateway.GlobalRateLimit.BurstSize = 100
	
	// 默认路径限流配置
	config.Gateway.RateLimits = []RateLimit{
		{
			Path:          "/api",
			RequestsPerSec: 100,
			BurstSize:     20,
		},
	}

	config.ServerSettings.MaxIdleConns = 100
	config.ServerSettings.MaxIdleConnsPerHost = 100
	config.ServerSettings.MaxConnsPerHost = 1000
	config.ServerSettings.LoadBalanceThreshold = 100
	config.ServerSettings.RequestTimeout = 30 // 默认30秒超时
	
	// 默认熔断器配置
	config.ServerSettings.CircuitBreaker = CircuitBreakerConfig{
		ErrorThreshold:      50.0, // 50%错误率触发熔断
		MinimumRequests:     20,   // 至少20个请求才触发熔断
		BreakDuration:       "30s",
		HalfOpenMaxRequests: 5,    // 半开状态最多处理5个请求
	}

	config.HealthCheck = HealthCheckConfig{
		Interval:      10,
		Timeout:       5,
		RetryInterval: 5,
		CheckPath:     "/health",
		CheckMethod:   "GET",
		SuccessCodes:  []int{200},
		CheckHeaders: map[string]string{
			"X-Health-Check": "true",
		},
	}
	
	// 默认日志配置
	config.Logging.Level = "info"
	config.Logging.Format = "text"
	config.Logging.TimeFormat = "2006-01-02 15:04:05"
	config.Logging.Output = "stdout"
	config.Logging.FilePath = "logs/gateway.log"

	return config
}

// GetDuration 解析持续时间字符串
func GetDuration(duration string) time.Duration {
	d, err := time.ParseDuration(duration)
	if err != nil {
		return 5 * time.Minute // 默认5分钟
	}
	return d
}
